home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / graphics / font3d10.zip / build.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-15  |  17.1 KB  |  552 lines
  1. //=================================================================================================
  2. //   Build.CPP
  3. //-------------------------------------------------------------------------------------------------
  4. //
  5. //   Copyright (c) 1994 by Todd A. Prater
  6. //   All rights reserved.
  7. //
  8. //=================================================================================================
  9.  
  10.  
  11. #include <stdlib.h>
  12. #include <fstream.h>
  13. #include "Config.H"
  14. #include "Vector.H"
  15. #include "TrueType.H"
  16. #include "Geometry.H"
  17. #include "Build.H"
  18.  
  19. #define IGNORE  2
  20. #define INSIDE  1
  21. #define OUTSIDE 0
  22.  
  23.  
  24.  
  25. //  ******************************************************
  26. //         NOTE:  Please excuse the debugging code
  27. //  ******************************************************
  28.  
  29.  
  30.  
  31. //===========================================================================================================
  32. //  PolygonizeContour                                                                                        
  33. //-----------------------------------------------------------------------------------------------------------
  34. //===========================================================================================================
  35.  
  36. void PolygonizeContour(TTFont&   font,
  37.                        USHORT  glyphnum,
  38.                        USHORT  contournum,
  39.                        USHORT  resolution,
  40.                        DOUBLE    depth,
  41.                        POLYGON&  polygon    )
  42. {
  43.  
  44.    ULONG  i,j;
  45.    ULONG  polyi;
  46.    ULONG  offcount,pointcount;
  47.    ULONG  consecutiveoffcount;
  48.    INT    lastwasoff;
  49.    INT    cur_type,prev_type,next_type;
  50.    VECTOR cp1,cp2,cp3,cur_point,prev_point,next_point;
  51.    DOUBLE cur_x,cur_y,prev_x,prev_y,next_x,next_y;
  52.    DOUBLE tstep;
  53.  
  54.    if (font.NumContours(glyphnum)<1)
  55.       return;
  56.  
  57.    if (contournum>=font.NumContours(glyphnum))
  58.       return;
  59.  
  60.    if(polygon.numpoints>0)
  61.    {
  62.       delete polygon.pointlist;
  63.       polygon.numpoints=0;
  64.    }
  65.  
  66.    lastwasoff=0; 
  67.    consecutiveoffcount=0; 
  68.    offcount=0;
  69.    for(i=0;i<font.NumPoints(glyphnum,contournum);i++)
  70.    {
  71. //      if (font.FontPointType(glyphnum,contournum,i)==ON_CURVE) cout<<i<<": ON"<<endl;
  72. //      else cout<<i<<": OFF"<<endl;
  73.       if(font.FontPointType(glyphnum,contournum,i)==OFF_CURVE)
  74.       {
  75.          offcount++;
  76.          if(lastwasoff)
  77.             consecutiveoffcount++;
  78.          lastwasoff=1;
  79.       }
  80.       else
  81.          lastwasoff=0;
  82.    }
  83.  
  84.    polygon.numpoints = font.NumPoints(glyphnum,contournum) + offcount*(resolution-2) + consecutiveoffcount;
  85.    polygon.pointlist = new VECTOR[polygon.numpoints+40];  // Temporary fix (give some playing room...)
  86.  
  87.    polyi=0;
  88.  
  89. //   pointcount = font.NumPoints(glyphnum,contournum);
  90.    for(i=0;i<font.NumPoints(glyphnum,contournum);i++)
  91.    {
  92.  
  93.       if (font.FontPointType(glyphnum,contournum,i)==ON_CURVE)
  94.       {
  95. //cout<<"OnCURVE: "<<i<<endl;
  96.          polygon.pointlist[polyi] = VECTOR((DOUBLE)font.FontPointX(glyphnum,contournum,i)/(DOUBLE)font.UnitsPerEm(),
  97.                                     (DOUBLE)font.FontPointY(glyphnum,contournum,i)/(DOUBLE)font.UnitsPerEm(), depth);
  98.          polyi++;
  99.       }
  100.       else
  101.       {
  102. //cout<<"OffCURVE:  "<<i<<endl;
  103.          if(font.FontPointType(glyphnum,contournum,i-1)==ON_CURVE)
  104.          {
  105.             cp1 = VECTOR((DOUBLE)font.FontPointX(glyphnum,contournum,i-1)/(DOUBLE)font.UnitsPerEm(),
  106.                         (DOUBLE)font.FontPointY(glyphnum,contournum,i-1)/(DOUBLE)font.UnitsPerEm(), depth);
  107.          }
  108.          else
  109.          {
  110.             cp1 = VECTOR(((DOUBLE)font.FontPointX(glyphnum,contournum,i-1)+(DOUBLE)font.FontPointX(glyphnum,contournum,i))/2/(DOUBLE)font.UnitsPerEm(),
  111.                         ((DOUBLE)font.FontPointY(glyphnum,contournum,i-1)+(DOUBLE)font.FontPointY(glyphnum,contournum,i))/2/(DOUBLE)font.UnitsPerEm(), depth);
  112.          }
  113.  
  114.          cp2 = VECTOR((DOUBLE)font.FontPointX(glyphnum,contournum,i)/(DOUBLE)font.UnitsPerEm(),
  115.                      (DOUBLE)font.FontPointY(glyphnum,contournum,i)/(DOUBLE)font.UnitsPerEm(), depth);
  116.  
  117.          if (i==(font.NumPoints(glyphnum,contournum)-1))
  118.          {
  119. //cout<<"THE LAST ONE"<<endl;
  120.             cp3 = VECTOR((DOUBLE)font.FontPointX(glyphnum,contournum,0)/(DOUBLE)font.UnitsPerEm(),
  121.                         (DOUBLE)font.FontPointY(glyphnum,contournum,0)/(DOUBLE)font.UnitsPerEm(), depth);
  122.          }
  123.          else
  124.          {
  125.             if(font.FontPointType(glyphnum,contournum,i+1)==ON_CURVE)
  126.             {
  127.                cp3 = VECTOR((DOUBLE)font.FontPointX(glyphnum,contournum,i+1)/(DOUBLE)font.UnitsPerEm(),
  128.                            (DOUBLE)font.FontPointY(glyphnum,contournum,i+1)/(DOUBLE)font.UnitsPerEm(), depth);
  129.                i++;
  130.             }
  131.             else
  132.             {
  133.                cp3 = VECTOR(((DOUBLE)font.FontPointX(glyphnum,contournum,i)+(DOUBLE)font.FontPointX(glyphnum,contournum,i+1))/2/(DOUBLE)font.UnitsPerEm(),
  134.                            ((DOUBLE)font.FontPointY(glyphnum,contournum,i)+(DOUBLE)font.FontPointY(glyphnum,contournum,i+1))/2/(DOUBLE)font.UnitsPerEm(), depth);
  135.             }
  136.          }
  137.  
  138.          tstep = 1.0/(DOUBLE)resolution;
  139.          for(j=0;j<resolution;j++)
  140.          {
  141.             polygon.pointlist[polyi] = ApproximateQuadraticSpline(cp1,cp2,cp3,tstep*(j+1));
  142.             polyi++;
  143.          }
  144.       }
  145.    }
  146.  
  147. if (   (polygon.pointlist[polyi-1].x==polygon.pointlist[0].x)
  148.     && (polygon.pointlist[polyi-1].y==polygon.pointlist[0].y))
  149. { 
  150. //cout<<"LAST IS FIRST"<<endl;
  151. polyi--;  //temporary fix....
  152. }
  153.  
  154.    polygon.numpoints = polyi;
  155.    polygon.orientation = polygon.findOrientation();
  156.  
  157. //cout<<polygon<<"P";
  158. }
  159.  
  160.  
  161.  
  162. //===========================================================================================================
  163. //  TriangulateFace                                                                                          
  164. //-----------------------------------------------------------------------------------------------------------
  165. //===========================================================================================================
  166.  
  167.  
  168. void TriangulateFace (TTFont&         font,
  169.                       USHORT        glyphnum,
  170.                       USHORT        resolution,
  171.                       DOUBLE           shrinkFactor,
  172.                       LIST<TRIANGLE>&  triangleList)
  173. {
  174.  
  175.  
  176.    int         i,j,k;
  177.    BOOLEAN     isAPair;
  178.    SHORT     contourCount;
  179.    POLYGON*    polyarray;
  180.    POLYGON*    shrunkpolyarray;
  181.    BYTEPTR*  relationship;
  182.  
  183. // cout<<"Beginning to triangulate..."<<endl;
  184.  
  185.    contourCount = font.NumContours(glyphnum);
  186.    if (contourCount<1) return;
  187.  
  188.    polyarray = new POLYGON[contourCount];
  189.    if (polyarray==NULL)
  190.    {
  191.       cout<<"ERROR: Out of memory."<<endl;
  192.       exit(1);
  193.    }
  194.  
  195.    shrunkpolyarray=new POLYGON[contourCount];
  196.    if (shrunkpolyarray==NULL)
  197.    {
  198.       cout<<"ERROR: Out of memory."<<endl;
  199.       exit(1);
  200.    }
  201.  
  202.    relationship = new BYTEPTR[contourCount];
  203.    if (relationship==NULL)
  204.    {
  205.       cout<<"ERROR: Out of memory."<<endl;
  206.       exit(1);
  207.    }
  208.    for (i=0;i<contourCount;i++)
  209.    {
  210.       relationship[i] = new BYTE[contourCount];
  211.       if (relationship[i]==NULL)
  212.       {
  213.          cout<<"ERROR: Out of memory."<<endl;
  214.          exit(1);
  215.       }
  216.    }
  217.  
  218.    for (i=0;i<contourCount;i++)
  219.    {
  220.       PolygonizeContour(font,glyphnum,i,resolution,0.0,polyarray[i]);
  221.       if (shrinkFactor>0.0)
  222.          polyarray[i].Shrink(shrunkpolyarray[i],shrinkFactor);
  223.    }
  224.  
  225.  
  226.  
  227.  
  228. //cout<<"All Contours Polygonized."<<endl;
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.    for (i=0;i<contourCount;i++)
  237.       for (j=0;j<contourCount;j++)
  238.          if (i==j)
  239.             relationship[i][j]=IGNORE;
  240.          else if (polyarray[j].isInside(polyarray[i]))
  241.             relationship[i][j]=INSIDE;
  242.          else
  243.             relationship[i][j]=OUTSIDE;
  244.  
  245.  
  246.    for (i=0;i<contourCount;i++)
  247.    {
  248.       if (polyarray[i].orientation==CLOCKWISE)
  249.       {
  250.          for (j=0;j<contourCount;j++)
  251.          {
  252.             isAPair=FALSE;
  253.             if (relationship[i][j]==INSIDE && polyarray[j].orientation==COUNTER_CLOCKWISE)
  254.             {
  255.                isAPair=TRUE;
  256.                for (k=0;k<contourCount;k++)
  257.                {
  258.                   if (k==j || k==i || relationship[k][j]==IGNORE) continue;
  259.                   if (relationship[k][j]==INSIDE)
  260.                   {
  261.                      if (relationship[i][k]==INSIDE)
  262.                      {
  263.                         isAPair=FALSE;
  264.                         exit;
  265.                      }
  266.                   }
  267.                   else
  268.                      continue;
  269.                }
  270.             }
  271.             if (isAPair)
  272.             {
  273.                if (shrinkFactor>0.0)
  274.                  shrunkpolyarray[i].Combine(shrunkpolyarray[j]);
  275.                else
  276.                   polyarray[i].Combine(polyarray[j]);
  277.  
  278.                relationship[i][j]=IGNORE;
  279.             }
  280.          }
  281.       }
  282.    }
  283.  
  284.  
  285.    for (i=0;i<contourCount;i++)
  286.    {
  287.       if (polyarray[i].orientation==CLOCKWISE)
  288.       {
  289.          if (shrinkFactor>0.0)
  290.             shrunkpolyarray[i].Triangulate(triangleList);
  291.          else
  292.             polyarray[i].Triangulate(triangleList);
  293.       }
  294.    }
  295.  
  296.  
  297.    for (i=0;i<contourCount;i++)
  298.    {
  299.       delete polyarray[i].pointlist;
  300.       delete shrunkpolyarray[i].pointlist;
  301.       delete relationship[i];
  302.    }
  303.    delete polyarray;
  304.    delete shrunkpolyarray;
  305.    delete relationship;
  306.  
  307. }
  308.  
  309.  
  310.  
  311. //===========================================================================================================
  312. //  TriangulateEdges                                                                                         
  313. //-----------------------------------------------------------------------------------------------------------
  314. //===========================================================================================================
  315.  
  316.  
  317. void TriangulateEdges(TTFont&          font,
  318.                       USHORT           glyphnum,
  319.                       USHORT           resolution,
  320.                       DOUBLE           frontDepth,
  321.                       DOUBLE           backDepth,
  322.                       DOUBLE           angleThreshold,
  323.                       LIST<TRIANGLE>&  tlist)
  324. {
  325.  
  326.  
  327.    INT         i,j,k;
  328.    TRIANGLE*   t1;
  329.    TRIANGLE*   t2;
  330.    VECTOR      previous,current1,current2,next;
  331.    VECTOR      previousFacet,currentFacet,nextFacet;
  332.    VECTOR      previousFacetNormal,currentFacetNormal,nextFacetNormal;
  333.    VECTOR      averageNormal1,averageNormal2;
  334.    VECTOR      p1,p2,p3,p4;
  335.    ULONG       numberOfPoints;
  336.    SHORT       contourCount;
  337.    POLYGON*    polyarray;
  338.    VECTOR      zDir(0,0,1);
  339.    DOUBLE      angle1,angle2;
  340.    
  341.    contourCount = font.NumContours(glyphnum);
  342.    if (contourCount<1) return;
  343.  
  344.    polyarray = new POLYGON[contourCount];
  345.    if (polyarray==NULL)
  346.    {
  347.       cout<<"ERROR: Out of memory."<<endl;
  348.       exit(1);
  349.    }
  350.  
  351.    for (i=0;i<contourCount;i++)
  352.       PolygonizeContour(font,glyphnum,i,resolution,0.0,polyarray[i]);
  353.  
  354.  
  355.  
  356.  
  357.    for (i=0;i<contourCount;i++)
  358.    {
  359.       numberOfPoints  = polyarray[i].numpoints;
  360.  
  361.       for (j=0;j<numberOfPoints;j++)
  362.       {
  363.  
  364.          if (j==numberOfPoints-2)
  365.          {
  366.             previous = polyarray[i].pointlist[j-1];
  367.             current1 = polyarray[i].pointlist[j];
  368.             current2 = polyarray[i].pointlist[j+1];
  369.             next     = polyarray[i].pointlist[0];
  370.          }
  371.          else if (j==numberOfPoints-1)
  372.          {
  373.             previous = polyarray[i].pointlist[j-1];
  374.             current1 = polyarray[i].pointlist[j];
  375.             current2 = polyarray[i].pointlist[0];
  376.             next     = polyarray[i].pointlist[1];
  377.          }
  378.          else if (j==0)
  379.          {
  380.             previous = polyarray[i].pointlist[numberOfPoints-1];
  381.             current1 = polyarray[i].pointlist[j];
  382.             current2 = polyarray[i].pointlist[j+1];
  383.             next     = polyarray[i].pointlist[j+2];
  384.          }
  385.          else
  386.          {
  387.             previous = polyarray[i].pointlist[j-1];
  388.             current1 = polyarray[i].pointlist[j];
  389.             current2 = polyarray[i].pointlist[j+1];
  390.             next     = polyarray[i].pointlist[j+2];
  391.          }
  392.  
  393.             
  394.          previousFacet = ~(current1-previous);
  395.          currentFacet  = ~(current2-current1);
  396.          nextFacet     = ~(next-current2);
  397.  
  398.          previousFacetNormal = zDir^previousFacet;
  399.          currentFacetNormal  = zDir^currentFacet;
  400.          nextFacetNormal     = zDir^nextFacet;
  401.  
  402.          angle1 = acos(previousFacetNormal%currentFacetNormal);
  403.          angle2 = acos(currentFacetNormal%nextFacetNormal);
  404.  
  405.          if (angle1<angleThreshold)
  406.             averageNormal1 = ~(previousFacetNormal+currentFacetNormal);
  407.          else
  408.             averageNormal1 = currentFacetNormal;
  409.  
  410.          if (angle2<angleThreshold)
  411.             averageNormal2 = ~(currentFacetNormal+nextFacetNormal);
  412.          else
  413.             averageNormal2 = currentFacetNormal;
  414.  
  415.          p1 = current1; p1.z=frontDepth;
  416.          p2 = current1; p2.z=backDepth;
  417.          p3 = current2; p3.z=frontDepth;
  418.          p4 = current2; p4.z=backDepth;
  419.  
  420.          t1 = new TRIANGLE(p1,p2,p3,averageNormal1,averageNormal1,averageNormal2);
  421.          if (t1==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  422.  
  423.          t2 = new TRIANGLE(p2,p3,p4,averageNormal1,averageNormal2,averageNormal2);
  424.          if (t2==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  425.  
  426.          tlist.Add(t1);
  427.          tlist.Add(t2);
  428.       }
  429.  
  430.    }
  431.  
  432.    delete polyarray;
  433.  
  434. }
  435.  
  436.  
  437.  
  438.  
  439.  
  440. //  This routine doesn't quite work yet.  Sometimes if the polygon is 'shrunk' too much,
  441. //  it can become self intersecting, which throws everything else off...
  442.  
  443. void TriangulateBevels(TTFont& font, INT code, INT resolution,
  444.                        DOUBLE frontDepth, DOUBLE backDepth,
  445.                        DOUBLE faceShrink, DOUBLE edgeShrink,
  446.                        LIST<TRIANGLE>& tlist)
  447. {
  448.    INT         i,j;
  449.    TRIANGLE*   t1;
  450.    TRIANGLE*   t2;
  451.    TRIANGLE*   t3;
  452.    TRIANGLE*   t4;
  453.    INT         glyphnum;
  454.    VECTOR       p1,p2,p3,p4,p5,p6,p7,p8;
  455.    SHORT     contourCount;
  456.    POLYGON*    frontFacePolyArray;
  457.    POLYGON*    frontEdgePolyArray;
  458.    POLYGON*    backFacePolyArray;
  459.    POLYGON*    backEdgePolyArray;
  460.  
  461.    glyphnum = font.CharacterMap(code);
  462.  
  463.    contourCount = font.NumContours(glyphnum);
  464.    if (contourCount<1) return;
  465.  
  466.    frontFacePolyArray = new POLYGON[contourCount];
  467.    if (frontFacePolyArray==NULL) {  cout<<"ERROR: Out of memory."<<endl; exit(1); }
  468.    frontEdgePolyArray = new POLYGON[contourCount];
  469.    if (frontEdgePolyArray==NULL) {  cout<<"ERROR: Out of memory."<<endl; exit(1); }
  470.    backFacePolyArray =  new POLYGON[contourCount];
  471.    if (backFacePolyArray==NULL) { cout<<"ERROR: Out of memory."<<endl; exit(1); }
  472.    backEdgePolyArray = new POLYGON[contourCount];
  473.    if (backEdgePolyArray==NULL) { cout<<"ERROR: Out of memory."<<endl; exit(1); }
  474.  
  475.    for (i=0;i<contourCount;i++)
  476.    {
  477.       PolygonizeContour(font,glyphnum,i,resolution,frontDepth,frontEdgePolyArray[i]);
  478.       PolygonizeContour(font,glyphnum,i,resolution,backDepth,backEdgePolyArray[i]);
  479.       frontEdgePolyArray[i].Shrink(frontFacePolyArray[i],faceShrink);
  480.       backEdgePolyArray[i].Shrink(backFacePolyArray[i],faceShrink);
  481.       frontEdgePolyArray[i].SetDepth(frontDepth-edgeShrink);
  482.       backEdgePolyArray[i].SetDepth(backDepth+edgeShrink);
  483.  
  484.       for (j=0;j<frontEdgePolyArray[i].numpoints-1;j++)
  485.       {
  486.          p1 = frontFacePolyArray[i].pointlist[j];
  487.          p2 = frontFacePolyArray[i].pointlist[j+1];
  488.          p3 = frontEdgePolyArray[i].pointlist[j];
  489.          p4 = frontEdgePolyArray[i].pointlist[j+1];
  490.          p5 = backEdgePolyArray[i].pointlist[j];
  491.          p6 = backEdgePolyArray[i].pointlist[j+1];
  492.          p7 = backFacePolyArray[i].pointlist[j];
  493.          p8 = backFacePolyArray[i].pointlist[j+1];
  494.  
  495.          cout<<"VECTORS: "<<p1<<p2<<p3<<p4<<p5<<p6<<p7<<p8<<endl;
  496.  
  497.          t1 = new TRIANGLE(p1,p3,p2);
  498.          if (t1==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  499.          t2 = new TRIANGLE(p2,p3,p4);
  500.          if (t2==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  501.          t3 = new TRIANGLE(p5,p7,p8);
  502.          if (t3==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  503.          t4 = new TRIANGLE(p5,p8,p6);
  504.          if (t4==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  505.  
  506.          tlist.Add(t1);
  507.          tlist.Add(t2);
  508.          tlist.Add(t3);
  509.          tlist.Add(t4);
  510.       }
  511.  
  512.       p1 = frontFacePolyArray[i].pointlist[j];
  513.       p2 = frontFacePolyArray[i].pointlist[0];
  514.       p3 = frontEdgePolyArray[i].pointlist[j];
  515.       p4 = frontEdgePolyArray[i].pointlist[0];
  516.       p5 = backEdgePolyArray[i].pointlist[j];
  517.       p6 = backEdgePolyArray[i].pointlist[0];
  518.       p7 = backFacePolyArray[i].pointlist[j];
  519.       p8 = backFacePolyArray[i].pointlist[0];
  520.  
  521.       t1 = new TRIANGLE(p1,p3,p2);
  522.       if (t1==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  523.       t2 = new TRIANGLE(p2,p3,p4);
  524.       if (t2==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  525.       t3 = new TRIANGLE(p5,p7,p8);
  526.       if (t3==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  527.       t4 = new TRIANGLE(p5,p8,p6);
  528.       if (t4==NULL) { cout<<"ERROR: Out of memory"<<endl; exit(1); }
  529.  
  530.       tlist.Add(t1);
  531.       tlist.Add(t2);
  532.       tlist.Add(t3);
  533.       tlist.Add(t4);
  534.  
  535.    }
  536.  
  537.    for (i=0;i<contourCount;i++)
  538.    {
  539.       delete frontFacePolyArray[i].pointlist;
  540.       delete frontEdgePolyArray[i].pointlist;
  541.       delete backEdgePolyArray[i].pointlist;
  542.       delete backFacePolyArray[i].pointlist;
  543.    }
  544.    delete frontFacePolyArray;
  545.    delete frontEdgePolyArray;
  546.    delete backFacePolyArray;
  547.    delete backEdgePolyArray;
  548.  
  549. }
  550.  
  551.  
  552.